// 这个是求两个数中最小值的函数，调用函数的时候需要传两个参数
function minNum(a, b) {
    var num = a > b ? b : a
    return num
}

// 这个是求两个数中最大值的函数，调用函数的时候需要传两个参数
function maxNum(a, b) {
    var num = a > b ? a : b
    return num
}

// 求任意多数最大值
function max() {
    // 假设第一个参数为最大的值
    var maxNum = arguments[0];
    // 遍历所有的实参
    for (var i = 0; i < arguments.length; i++) {
        // 把假设的最大值与所有实参比较，如果有一个值大于假设的最大值，就把这个值赋值给 maxNum
        if (maxNum < arguments[i]) {
            maxNum = arguments[i]
        }
    }
    return maxNum
}

function min() {
    // 假设第一个参数为最小的值
    var minNum = arguments[0];
    // 遍历所有的实参
    for (var i = 0; i < arguments.length; i++) {
        // 把假设的最小值与所有实参比较，如果有一个值小于假设的最小值，就把这个值赋值给 maxNum
        if (minNum > arguments[i]) {
            minNum = arguments[i]
        }
    }
    return minNum
}

// 任意两个数之间的随机数  调用函数的时候需要传两个数值的参数
function randomNum(n, m) {
    // 判断两个参数的大小
    var max, min;
    max = n > m ? n : m;
    min = n < m ? n : m;
    return parseInt(Math.random() * (max - min + 1) + min);

}

// 封装一个生成随机颜色的函数
function randomColor() {
    var red = randomNum(0, 255);
    var green = randomNum(0, 255);
    var blue = randomNum(0, 255);
    return 'rgb(' + red + ',' + green + ',' + blue + ')'
}

/*
    封装一个事件格式化的函数 2020-6-19 15:09:49 星期五
*/
function dates(date) {
    var year = date.getFullYear();
    var month = date.getMonth() + 1;
    var dates = date.getDate();

    var h = date.getHours();
    // 判断h这个是是否值小于 10的值，比如h = 9,应该显示W为 09
    h = h >= 10 ? h : '0' + h;

    var m = date.getMinutes();
    m = m >= 10 ? m : '0' + m;

    var s = date.getSeconds();
    s = s >= 10 ? s : '0' + s;

    var day = date.getDay(); //0-6  0表示星期天

    var arr = ['星期天', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六']

    // 把格式化号的 时间返回
    return year + '-' + month + '-' + dates + ' ' + h + ':' + m + ':' + s + '  ' + arr[day]
}

// 求两个时间的时间差
function chaTime(date1, date2, callback) {
    var time1 = date1.getTime(); //得到是 date1到格林威治时间的毫秒数
    var time2 = date2.getTime(); //得到是 date2到格林威治时间的毫秒数

    // 得到两个时间的时间差（毫秒数）
    var chaTime = Math.abs(time1 - time2);
    var day = parseInt(chaTime / 1000 / 60 / 60 / 24);

    var hours = parseInt((chaTime / 1000 / 60 / 60) % 24);
    var m = parseInt((chaTime / 1000 / 60) % 60);

    var s = parseInt((chaTime / 1000) % 60);

    // 固定 return ，获取时间差只能做一个功能，不能灵活的使用这个函数
    // return '两个相差' + day + '天' + hours + '小时' + m + '分' + s + '秒'

    // 利用回调函数 把 已经计算好的时间差 返回到 函数的外部，
    // callback 回调函数的形参
    // 因为 时间差 有天数，小时，分钟，秒数，单个参数传递的时候，函数的实参和形参
    // 可以利用对象的形式传递
    var obj = {
        day: day,
        hours: hours,
        minutes: m,
        seconds: s
    }
    callback(obj);
}

// 封装一个函数 来获取非行内样式
function getStyle(ele, attr) {
    var style;
    if (ele.currentStyle) {
        //  ele.currentStyle 包含 所有css样式的对象
        // obj.attr 获取 obj的 attr的属性
        style = ele.currentStyle[attr];
    } else {
        style = window.getComputedStyle(ele)[attr];
    }
    // 把获取的样式返回
    return style
}

// 监听事件 
/* 
    当执行这个函数
    必须的参数
        ele:事件源 
        type:事件类型（不需要加on）
        callback ：回调函数，用来作为事件处理函数，执行事件需要写的代码都写callback中
*/
function attaEvent(ele, type, callback) {
    if (ele.addEventListener) {
        ele.addEventListener(type, function () {
            callback()
        })
    } else {
        ele.attachEvent('on' + type, function () {
            callback()
        })
    }
}

/* 
    运动函数： 有3个参数
    参数1：dom元素 参加动画元素
    参数2：一个对象，这个元素什么属性参加动画
    参数3：一个回调函数
*/
function move(ele, obj, callback) {

    let timerLen = 0;
    for (let key in obj) {
        timerLen++
        let speed;
        clearInterval(ele[key])
        // 给这个对象添加一个 left 属性，属性值为 一个定时器的空间地址
        ele[key] = setInterval(() => {
            let style;
            // 0-1 *100 == 0-100   0.1*100 = 10
            if (key === 'opacity') {
                style = getStyle(ele, key) * 100;
            } else {
                style = parseInt(getStyle(ele, key));
            }
            // 0 - 4 = -4/5 = -0.8 向上取整 = 0
            speed = (obj[key] - style) / 5;

            // 如果计算出来的 speed 大于0 向上取整，如果小于0就向下取整
            speed = speed > 0 ? Math.ceil(speed) : Math.floor(speed);
            style = style + speed;

            if (key === 'opacity') {
                ele.style[key] = style / 100;
            } else {
                ele.style[key] = style + 'px';
            }

            // 如果先执行回调函数 再给 元素设置 样式，会先把回调函数中的 所有 代码执行完成之后再执行后面代码
            if (style === obj[key]) {
                clearInterval(ele[key]);
                timerLen--;
                if (timerLen === 0) {
                    // 短路运算 如果有callback 就执行callback，没有就不执行
                    callback && callback();
                }
            }
            // style = -3000
            // if (key === 'opacity') {
            //     ele.style[key] = style / 100;
            // } else {
            //     ele.style[key] = style + 'px';
            // }
            // 当时间 为60的时候，30次 1800毫秒 才能把内层的定时器执行完成
            // 外层的定时器 是1300毫秒执行一次，会造成的问题就是 内层的定时器还没有执行完成 外层定时器有重新执行了

            // if (style === obj[key]) {
            //     clearInterval(ele[key]);
            //     timerLen--;
            //     if (timerLen === 0) {
            //         // 短路运算 如果有callback 就执行callback，没有就不执行
            //         callback && callback();
            //     }
            // } else {
            //     if (key === 'opacity') {
            //         ele.style[key] = (style + speed) / 100;
            //     } else {
            //         ele.style[key] = style + speed + 'px';
            //     }
            // }

        }, 30)
    }

}